import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class test {
    static int count = 0;
    public static void main(String[] args) {
        int c = 0;
        //并发编程的工具包
        //  new ReentrantLock(true); 传true 公平锁 false 非公平锁
        ReentrantLock reentrantLock = new ReentrantLock();
        new Thread(()->{
            reentrantLock.lock();
            count ++;
            reentrantLock.unlock();
        }).start();

        new Thread(()->{
            reentrantLock.lock();
            count ++;
            reentrantLock.unlock();
        }).start();
    }
    static class MyReentrantLock implements Lock {

        private final Sync sync;

        MyReentrantLock(boolean fair){
            this.sync = fair ? new FairSync() : new NonfairSync();
        }

        abstract static class Sync extends AbstractQueuedSynchronizer{
            final void lock(){
                acquire(1);
            }
        }

        //非公平锁，使state由0变为1即可。
         final class NonfairSync extends Sync{
            @Override
            protected boolean tryAcquire(int arg) {
                int c = getState();
                final Thread current = Thread.currentThread();
                //state为0 ，说明没有线程拿到这个锁资源
                if(c == 0){
                    //CAS操作：保证0变为1的时候不会发生并发问题
                    if(compareAndSetState(0,arg)) {
                        //setExclusiveOwnerThread 告诉AQS独占线程是哪个
                        setExclusiveOwnerThread(current);
                        //返回true，拿到了一个锁资源
                        return true;
                        //加锁这个的线程是不是已经拿到锁的线程
                        //可重入锁:一个线程加锁后可以对该锁继续加锁。
                        //getExclusiveOwnerThread 获得AQS的独占线程
                        //getExclusiveOwnerThread和setExclusiveOwnerThread不是AQS的，AQS父类AOS。Own
                    } else if(current == getExclusiveOwnerThread()){
                        setState(c + arg);
                        return true;
                    }
                }
                return false;
            }
        }

        class FairSync extends Sync{
            @Override
            protected boolean tryAcquire(int arg) {
                int c = getState();
                final Thread current = Thread.currentThread();
                if(c == 0){
                    //AQS 该线程的head还有没有线程，有就不能获得锁

                    if(!hasQueuedPredecessors() && compareAndSetState(0,arg)){
                        setExclusiveOwnerThread(current);
                        return true;
                    } else if(current == getExclusiveOwnerThread()){
                        setState(c + arg);
                        return true;
                    }
                }
                return false;
            }
        }

        /**
         * ReentrantLock 实现原理：主要根据AQS实现。队列（双端队列）。 线程
         * AQS实现。队列（双端队列）。 线程。 公平锁：排队，先到先得。
         * 状态量作用。state 为0 ，说明没有锁资源，不为0就说明存在抢占了锁的线程。非公平锁。state操作API，AQS都包含
         *
         * ReentrantLock.lock()的流程：lock()->  sync.lock()-> AQS的acquire()方法
         * -> sync 内部类决定是非公平锁（NonfairSync） 还是公平锁（FairSync）的tryAcquire();
         *
         */
        public void lock() {
            sync.lock();
        }

        public void unlock() {

        }

        public void lockInterruptibly() throws InterruptedException {

        }

        public boolean tryLock() {
            return false;
        }

        public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
            return false;
        }



        public Condition newCondition() {
            return null;
        }
    }
}
